The invention relates to debugging of computer code. More specifically, the invention relates to a method and apparatus for debugging computer code that does not require modification of the target executable program that is to be debugged.
Computer programming has become a very complex operation because of the increased sophistication of computers and the increased complexity of tasks to be carried out by computers. Further, computer hardware is now relied upon for mission critical tasks, such as air traffic control, communications, medical equipment, and the like. It follows that computer software, i.e. a computer program, is controlling these tasks. Note that the phrase xe2x80x9ccomputer programxe2x80x9d is used herein to refer to a set of software instructions and/or routines for controlling computer hardware. The word xe2x80x9capplicationxe2x80x9d is used herein to refer to the practical use of the program, for example, inventory control, accounting or any other use.
Of course, a higher level of software complexity results in a higher potential for programming errors, known as xe2x80x9cbugsxe2x80x9d. For example, many programs consist of thousands or even millions of lines of code. The sheer volume of code creates great potential for bugs. Also, as a result of the size of most computer programs, the code often is developed by plural teams of programmers each working on a different portion or aspect of the program. The teams may accomplish similar tasks in a different manner or otherwise produce code that is incompatible with code developed by other teams. Due to the huge reliance on computer software in just about every aspect of society, it is important to find and eliminate as many bugs as possible in an efficient manner. Also, it is often desirable to insure the performance of a computer program. For example, the end user may want to be guaranteed that a particular variable is updated very quickly.
To find errors in code and assure performance, a process called xe2x80x9cdebuggingxe2x80x9d has developed. One form of conventional debugging is called xe2x80x9cinteractive debuggingxe2x80x9d. Interactive debugging includes stopping the program at desired break points, known as xe2x80x9cbreaksxe2x80x9d, for examination of program status. xe2x80x9cNoninteractive debuggingxe2x80x9d does not stop the program. However it uses debugging statements which are inserted into the source code and the source code is then compiled into machine code including the debugging statements. Once all errors have been eliminated and the program is operating in a desirable manner, the debugging statements are removed from the source code and the program is recompiled and used for its intended task.
Conventional debugging techniques, while sometimes effective, have several shortcomings. In particular, conventional noninteractive debugging techniques require access to the source code for insertion of the debugging statements. Often, the user license for a particular program does not grant access to the source code or the right to change the source code. Therefore, in most cases, the user must rely on the developer of the software to provide all debugging. Often programming errors occur only in a particular application of a program and thus are not caught by the developer during initial debugging. Also, the developer may be unavailable or unwilling to provide subsequent debugging services. Further, even if access to the source code is not an obstacle, the program as run during noninteractive debugging has been altered to accommodate the debugging statements. Therefore, the program might not run in the same manner during debugging as it will during normal operation. The debugging statements may mask errors, create errors, slow operation, or otherwise affect the function or performance of the program. Finally, many programs behave differently or even refuse to run when stopped. Therefore, conventional interactive debugging using break points is not reliable and is difficult to implement.
It is an object of the invention to overcome the limitations of conventional debugging techniques.
It is another object of the invention to permit debugging of a computer program without stopping execution of the program.
It is another object of the invention to permit noninteractive debugging of a computer program without accessing or altering the source code of the program.
It is another object of the invention to conduct performance testing of a computer program under actual executable conditions of the program.
It is another object of the invention to conduct requirement verification under actual executable conditions of the program.
It is another object of the invention to increase the speed and efficiency of software development.
It is another object of the invention to facilitate software comprehension.
The invention uses xe2x80x9cdynamic linkingxe2x80x9d to use the existing target program executable for debugging and thus avoids the long edit-compile-link cycles inherent in the use of debugging statements in source code. By linking new user actions into the executable image, the target program is allowed to run as it would normally run thus allowing debugging of time sensitive programs without the need to stop execution thereof. Calls to the user actions are inserted into the memory image during loading of the target program. The calls can be inserted at any time during or after transfer of the executable code into memory. Accordingly, the term xe2x80x9cloadingxe2x80x9d as used herein refers to any time during or after transfer of the target program into memory for the purpose of running the program. The invention can be used to locate and fix programming errors, for requirements verification, for performance evaluation, for software comprehension, or for any other evaluation of software. Accordingly, the term xe2x80x9cdebuggingxe2x80x9d as used herein refers broadly to any type of diagnosis or evaluation of software.
A first aspect of the invention is a method for debugging a computer program comprising the steps of developing a debugging subprogram having a user action for debugging a target program, loading the target program for execution, inserting a call to the debugging subprogram into a memory image of the target program during the loading step, and executing the target program.
A second aspect of the invention is a computer readable medium having instructions for debugging a computer program recorded thereon. The medium a includes a first set of instructions for loading the target program for execution, and a second set of instructions for inserting a call to a debugging subprogram having user actions into a memory image of the target program during loading of the target program.